home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt3sp2.arc / PIBDIALA.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-09-25  |  52.5 KB  |  1,408 lines
  1. (*----------------------------------------------------------------------*)
  2. (*                PibDialer --- Dialing Management                      *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. OVERLAY PROCEDURE PibDialer( ReDial         : BOOLEAN;
  6.                              Dialing_String : AnyStr );
  7.  
  8. (*----------------------------------------------------------------------*)
  9. (*                                                                      *)
  10. (*     Procedure:  PibDialer                                            *)
  11. (*                                                                      *)
  12. (*     Purpose:    Main routine for dials/redials                       *)
  13. (*                                                                      *)
  14. (*     Calling Sequence:                                                *)
  15. (*                                                                      *)
  16. (*        PibDialer( ReDial         : BOOLEAN;                          *)
  17. (*                   Dialing_String : AnyStr );                         *)
  18. (*                                                                      *)
  19. (*           ReDial --- TRUE for redial, FALSE for ordinary dial        *)
  20. (*           Dialing_String --- if not null, use this as number to      *)
  21. (*                              be dialed.                              *)
  22. (*                                                                      *)
  23. (*     Calls:                                                           *)
  24. (*                                                                      *)
  25. (*           Dial_A_Number                                              *)
  26. (*           Redial_A_Number                                            *)
  27. (*                                                                      *)
  28. (*    Remarks:                                                          *)
  29. (*                                                                      *)
  30. (*        This routine exists solely to route calls to Dial_A_Number    *)
  31. (*        and Redial_A-Number.  This setup is used so that the Turbo    *)
  32. (*        Pascal overlay scheme will work correctly.                    *)
  33. (*                                                                      *)
  34. (*----------------------------------------------------------------------*)
  35.  
  36. VAR
  37.    Local_Save_4   : Saved_Screen_Ptr;
  38.    Session_Active : BOOLEAN;
  39.    Xpos1          : INTEGER;
  40.    Manual_Dial    : BOOLEAN;
  41.    Quit           : BOOLEAN;
  42.  
  43. (*----------------------------------------------------------------------*)
  44. (*          Dialer_Carrier_Detect --- Look for carrier detect           *)
  45. (*----------------------------------------------------------------------*)
  46.  
  47. FUNCTION Dialer_Carrier_Detect : BOOLEAN;
  48.  
  49. (*----------------------------------------------------------------------*)
  50. (*                                                                      *)
  51. (*     Function:  Dialer_Carrier_Detect                                 *)
  52. (*                                                                      *)
  53. (*     Purpose:   Looks for a carrier detect                            *)
  54. (*                                                                      *)
  55. (*     Calling Sequence:                                                *)
  56. (*                                                                      *)
  57. (*        Carrier := Dialer_Carrier_Detect;                             *)
  58. (*                                                                      *)
  59. (*           Carrier  --- TRUE if carrier detect found                  *)
  60. (*                                                                      *)
  61. (*     Calls:                                                           *)
  62. (*                                                                      *)
  63. (*        Async_Carrier_Detect;                                         *)
  64. (*                                                                      *)
  65. (*     Remarks:                                                         *)
  66. (*                                                                      *)
  67. (*        This routine is essentially a filter for Async_Carrier_Detect *)
  68. (*        except that if the global flag Modem_Carrier_High is set, it  *)
  69. (*        returns FALSE.  This is to support modems which always keep   *)
  70. (*        the carrier detect line high.                                 *)
  71. (*                                                                      *)
  72. (*----------------------------------------------------------------------*)
  73.  
  74. BEGIN (* Dialer_Carrier_Detect *)
  75.  
  76.    IF Modem_Carrier_High THEN
  77.       Dialer_Carrier_Detect := FALSE
  78.    ELSE
  79.       Dialer_Carrier_Detect := Async_Carrier_Detect;
  80.  
  81. END   (* Dialer_Carrier_Detect *);
  82.  
  83. (*----------------------------------------------------------------------*)
  84. (*          Read_Number_Or_ESC --- Read in number or get escape         *)
  85. (*----------------------------------------------------------------------*)
  86.  
  87. PROCEDURE Read_Number_Or_ESC(     Ch        : CHAR;
  88.                                   Xpos      : INTEGER;
  89.                               VAR SNumber   : AnyStr;
  90.                               VAR P_Str     : AnyStr;
  91.                               VAR Esc_Found : BOOLEAN;
  92.                               VAR Number    : INTEGER );
  93.  
  94. (*----------------------------------------------------------------------*)
  95. (*                                                                      *)
  96. (*     Procedure:  Read_Number_Or_ESC                                   *)
  97. (*                                                                      *)
  98. (*     Purpose:    Reads in number and reports if escape hit.           *)
  99. (*                                                                      *)
  100. (*     Calling Sequence:                                                *)
  101. (*                                                                      *)
  102. (*        Read_Number_Or_ESC(     Ch        : CHAR;                     *)
  103. (*                                Xpos      : INTEGER;                  *)
  104. (*                            VAR Snumber   : AnyStr;                   *)
  105. (*                            VAR P_Str     : AnyStr;                   *)
  106. (*                            VAR Esc_Found : BOOLEAN;                  *)
  107. (*                            VAR Number    : INTEGER );                *)
  108. (*                                                                      *)
  109. (*           Ch        --- First character in number (input)            *)
  110. (*           XPos      --- First column of answer                       *)
  111. (*           Snumber   --- Full number if found                         *)
  112. (*           P_Str     --- Prefix string if any found                   *)
  113. (*           Esc_Found --- Escape encountered                           *)
  114. (*           Number    --- Resultant number                             *)
  115. (*                                                                      *)
  116. (*     Calls:                                                           *)
  117. (*                                                                      *)
  118. (*        Menu_Beep                                                     *)
  119. (*                                                                      *)
  120. (*----------------------------------------------------------------------*)
  121.  
  122. VAR
  123.    IX      : INTEGER;
  124.    IY      : INTEGER;
  125.    Ierr    : INTEGER;
  126.  
  127. BEGIN (* Read_Number_Or_ESC *)
  128.  
  129.                                    (* Initialize arguments         *)
  130.    ESC_Found := FALSE;
  131.    SNumber   := '';
  132.    P_Str     := '';
  133.    Number    := 0;
  134.                                    (* Loop over input and pick up   *)
  135.                                    (* number, possibly with dialing *)
  136.                                    (* prefix, or ESC.               *)
  137.    REPEAT
  138.  
  139.       IF ( Ch <> CHR( CR ) ) AND ( Ch <> ';' ) THEN
  140.          BEGIN (* Not CR *)
  141.  
  142.             IF Ch = ^H THEN
  143.                BEGIN  (* Backspace *)
  144.                   IF WhereX > Xpos THEN
  145.                      BEGIN
  146.                         IY := WhereX;
  147.                         GoToXY( IY - 1 , WhereY );
  148.                         WRITE(' ');
  149.                         GoToXY( IY - 1 , WhereY );
  150.                         IF LENGTH( Snumber ) > 1 THEN
  151.                            Snumber := COPY( Snumber, 2, LENGTH( Snumber ) - 1 )
  152.                         ELSE
  153.                            Snumber := '';
  154.                      END;
  155.                END   (* Backspace *)
  156.             ELSE IF ( Ch = CHR( ESC ) ) THEN
  157.                BEGIN  (* Escape found *)
  158.                   ESC_Found := TRUE;
  159.                   Snumber   := '';
  160.                END    (* Escape found *)
  161.             ELSE
  162.                BEGIN
  163.                   Snumber := Snumber + Ch;
  164.                   WRITE( Ch );
  165.                END;
  166.  
  167.             IF ( NOT ESC_Found ) THEN
  168.                READ( Kbd, Ch );
  169.  
  170.          END (* Not CR *);
  171.  
  172.    UNTIL ( Ch = CHR( CR ) ) OR ( Ch = ';' ) OR ESC_Found;
  173.  
  174.                                    (* No number entered -- quit *)
  175.  
  176.    IF ( LENGTH( Snumber ) <= 0 ) OR ( ESC_Found ) THEN EXIT;
  177.  
  178.                                    (* Remove prefix if any *)
  179.  
  180.    IF Snumber[1] IN ['+','-','!','@','#'] THEN
  181.       BEGIN
  182.          P_Str      := Phone_Prefix_Nos[ POS( Snumber[1], '+-!@#' ) ];
  183.          Snumber    := COPY( Snumber, 2, LENGTH( Snumber ) - 1 );
  184.       END;
  185.                                    (* Convert number *)
  186.    Number := 0;
  187.    Ierr   := 0;
  188.  
  189.    FOR IX := 1 TO LENGTH( Snumber ) DO
  190.       IF Snumber[IX] IN ['0'..'9'] THEN
  191.          Number := Number * 10 + ORD( Snumber[IX] ) - ORD('0')
  192.       ELSE IF UpCase( Snumber[IX] ) <> 'M' THEN
  193.          Ierr := 1;
  194.                                    (* If bad, beep and ignore. *)
  195.    IF ( Ierr > 0 ) THEN
  196.       BEGIN
  197.          Menu_Beep;
  198.          EXIT;
  199.       END;
  200.  
  201. END   (* Read_Number_Or_ESC *);
  202.  
  203. (*----------------------------------------------------------------------*)
  204. (*    Reset_Comm_Params --- Reset comm. parms. from dialing entry       *)
  205. (*----------------------------------------------------------------------*)
  206.  
  207. PROCEDURE Reset_Comm_Params( Phone_Entry_Data: Phone_Number_Record ) ;
  208.  
  209. (*----------------------------------------------------------------------*)
  210. (*                                                                      *)
  211. (*     Procedure:  Reset_Comm_Params                                    *)
  212. (*                                                                      *)
  213. (*     Purpose:    Resets communications parameters (baud,parity,bits)  *)
  214. (*                 according to selected dialing directory entry.       *)
  215. (*                                                                      *)
  216. (*     Calling Sequence:                                                *)
  217. (*                                                                      *)
  218. (*        Reset_Comm_Params( Phone_Entry_Data: Phone_Number_Record );   *)
  219. (*                                                                      *)
  220. (*           Phone_Entry_Data --- data record for a dialing entry       *)
  221. (*                                                                      *)
  222. (*     Calls:                                                           *)
  223. (*                                                                      *)
  224. (*        Async_Reset_Port                                              *)
  225. (*                                                                      *)
  226. (*----------------------------------------------------------------------*)
  227.  
  228. VAR
  229.    Qerr: BOOLEAN;
  230.    S:    ShortStr;
  231.    I:    INTEGER;
  232.    J:    INTEGER;
  233.  
  234. BEGIN (* Reset_Comm_Params *)
  235.  
  236.    WITH Phone_Entry_Data DO
  237.       BEGIN
  238.  
  239.          S := Phone_Baud;
  240.  
  241.          I := 0;
  242.  
  243.          FOR J := 1 TO LENGTH( S ) DO
  244.             IF S[J] IN ['0'..'9'] THEN
  245.                I := I * 10 + ORD( S[J] ) - ORD('0');
  246.  
  247.          Baud_Rate := I;
  248.  
  249.          Parity := Phone_Parity;
  250.  
  251.          Data_Bits := ORD( Phone_DataBits ) - ORD('0');
  252.  
  253.          Stop_Bits := ORD( Phone_StopBits ) - ORD('0');
  254.  
  255.          Async_Reset_Port( Comm_Port, Baud_Rate,
  256.                            Parity, Data_Bits, Stop_Bits );
  257.  
  258.       END;
  259.  
  260. END   (* Reset_Comm_Params *);
  261.  
  262. (*----------------------------------------------------------------------*)
  263. (*         Display_Phone_Numbers --- display dialing directory          *)
  264. (*----------------------------------------------------------------------*)
  265.  
  266. PROCEDURE Display_Phone_Numbers( VAR Phone_Number: AnyStr;
  267.                                  VAR Prefix_Str  : AnyStr;
  268.                                  VAR Esc_Hit     : BOOLEAN );
  269.  
  270. (*----------------------------------------------------------------------*)
  271. (*                                                                      *)
  272. (*     Procedure:  Display_Phone_Numbers                                *)
  273. (*                                                                      *)
  274. (*     Purpose:    Displays dialing directory and prompts for # to dial *)
  275. (*                                                                      *)
  276. (*     Calling Sequence:                                                *)
  277. (*                                                                      *)
  278. (*        Display_Phone_Numbers( VAR Phone_Number: AnyStr;              *)
  279. (*                               VAR Prefix_Str  : AnyStr;              *)
  280. (*                               VAR Esc_Hit     : BOOLEAN );           *)
  281. (*                                                                      *)
  282. (*           Phone_Number --- phone number to dial (if any)             *)
  283. (*           Prefix_Str   --- prefix string to use                      *)
  284. (*           Esc_Hit      --- TRUE if ESC hit to exit dialing           *)
  285. (*                                                                      *)
  286. (*     Calls:   Display_Directory_Page                                  *)
  287. (*              Save_Screen                                             *)
  288. (*              Restore_Screen                                          *)
  289. (*              Draw_Menu_Frame                                         *)
  290. (*              Reset_Global_Colors                                     *)
  291. (*              Dialer_Carrier_Detect                                   *)
  292. (*                                                                      *)
  293. (*----------------------------------------------------------------------*)
  294.  
  295. CONST
  296.    N_nos = 15                      (* No. of phone numbers displayed *);
  297.  
  298. VAR
  299.    Phone_Entries: ARRAY[ 1 .. N_Nos ] OF Phone_Number_Record;
  300.    Fixed_Entry  : Phone_Number_Record;
  301.    Low_Num      : INTEGER;
  302.    Hi_Num       : INTEGER;
  303.    Done         : BOOLEAN;
  304.    I            : INTEGER;
  305.    J            : INTEGER;
  306.    L            : INTEGER;
  307.    Dial_Func    : CHAR;
  308.    Snumber      : STRING[40];
  309.    Local_Save   : Saved_Screen_Ptr;
  310.    Local_Save_2 : Saved_Screen_Ptr;
  311.    Local_Save_3 : Saved_Screen_Ptr;
  312.    Qerr         : BOOLEAN;
  313.    XPos         : INTEGER;
  314.    YPos         : INTEGER;
  315.    ReDraw       : BOOLEAN;
  316.  
  317. (*----------------------------------------------------------------------*)
  318. (*   Display_Directory_Page --- display a page of phone directory       *)
  319. (*----------------------------------------------------------------------*)
  320.  
  321. PROCEDURE Display_Directory_Page;
  322.  
  323. (*----------------------------------------------------------------------*)
  324. (*                                                                      *)
  325. (*     Procedure:  Display_Directory_Page                               *)
  326. (*                                                                      *)
  327. (*     Purpose:    Displays one page of dialing directory               *)
  328. (*                                                                      *)
  329. (*     Calling Sequence:                                                *)
  330. (*                                                                      *)
  331. (*        Display_Directory_Page;                                       *)
  332. (*                                                                      *)
  333. (*     Calls:   None                                                    *)
  334. (*                                                                      *)
  335. (*----------------------------------------------------------------------*)
  336.  
  337. BEGIN (* Display_Directory_Page *)
  338.                                    (* Get to first line of display *)
  339.    GoToXY( 1 , 1 );
  340.                                    (* Pick up phone numbers        *)
  341.    L      := 0;
  342.  
  343.    FOR I := Low_Num TO Hi_Num DO
  344.       BEGIN
  345.             (*$I-*)
  346.          SEEK( Phone_File , I - 1 );
  347.             (*$I+*)
  348.          IF Int24Result = 0 THEN
  349.             BEGIN
  350.                L      := L + 1;
  351.                READ( Phone_File , Phone_Entries[ L ] );
  352.             END;
  353.       END;
  354.  
  355.                                    (* Display entries              *)
  356.  
  357.    RvsVideoOn( ForeGround_Color , BackGround_Color );
  358.  
  359.    FOR I := 1 TO L DO
  360.       WITH Phone_Entries[I] DO
  361.          BEGIN
  362.             J := Low_Num + I - 1;
  363.             WRITELN( J:3, '  ',  Phone_Name:25,  '  ',  Phone_Number:15,
  364.                           '   ', Phone_Baud:5,   '    ', Phone_DataBits:1,
  365.                           '      ', Phone_Parity:1, '     ', Phone_StopBits:1 );
  366.             RvsVideoOff( ForeGround_Color , BackGround_Color );
  367.          END;
  368.                                    (* Blank out any remaining lines *)
  369.    FOR I := ( L + 1 ) TO N_Nos DO
  370.       BEGIN
  371.          GoToXY( 1 , I );
  372.          ClrEol;
  373.       END;
  374.  
  375. END   (* Display_Directory_Page *);
  376.  
  377. (*----------------------------------------------------------------------*)
  378. (*          Revise_Phone_Entry --- Revise phone directory entry         *)
  379. (*----------------------------------------------------------------------*)
  380.  
  381. PROCEDURE Revise_Phone_Entry;
  382.  
  383. (*----------------------------------------------------------------------*)
  384. (*                                                                      *)
  385. (*     Procedure:  Revise_Phone_Entry                                   *)
  386. (*                                                                      *)
  387. (*     Purpose:    Handles revision of dialing directory entry          *)
  388. (*                                                                      *)
  389. (*     Calling Sequence:                                                *)
  390. (*                                                                      *)
  391. (*        Revise_Phone_Entry;                                           *)
  392. (*                                                                      *)
  393. (*     Calls:   Save_Screen                                             *)
  394. (*              Draw_Menu_Frame                                         *)
  395. (*              Save_Screen                                             *)
  396. (*              Restore_Screen                                          *)
  397. (*                                                                      *)
  398. (*----------------------------------------------------------------------*)
  399.  
  400. VAR
  401.    J:    INTEGER;
  402.    Quit: BOOLEAN;
  403.    Ch  : CHAR;
  404.  
  405. BEGIN (* Revise_Phone_Entry *)
  406.                                    (* Get number to revise *)
  407.    Save_Screen( Local_Save_2 );
  408.  
  409.    Window( 1, 1, 80, 25 );
  410.  
  411.    Draw_Menu_Frame( 10, 2, 51, 6, Menu_Frame_Color,
  412.                     Menu_Text_Color, 'Revise Dialing Entry');
  413.  
  414.    Quit := FALSE;
  415.                                    (* Request the entry number *)
  416.  
  417.    WRITE('Entry to revise ? ');
  418.    READ( Kbd , Ch );
  419.  
  420.    Read_Number_Or_ESC( Ch , WhereX - 1, SNumber, Prefix_Str, Quit, J );
  421.  
  422.                                    (* Exit if none entered *)
  423.    IF  ( Quit OR ( J <= 0 ) ) THEN
  424.       BEGIN
  425.          Restore_Screen( Local_Save_2 );
  426.          EXIT;
  427.       END;
  428.                                    (* Look for it on file  *)
  429.        (*$I-*)
  430.    SEEK( Phone_File , J - 1 );
  431.        (*$I+*)
  432.                                    (* If not found, quit revision *)
  433.    IF Int24Result <> 0 THEN
  434.       BEGIN
  435.          WRITELN;
  436.          WRITELN('No such entry.');
  437.          DELAY( Two_Second_Delay );
  438.       END
  439.    ELSE                            (* Otherwise pick up entry's data *)
  440.       BEGIN (* Entry exists *)
  441.  
  442.          READ( Phone_File , Fixed_Entry );
  443.  
  444.          Restore_Screen( Local_Save_2 );
  445.  
  446.                                    (* Bring up revision window *)
  447.          Save_Screen( Local_Save_2 );
  448.  
  449.          Window( 1, 1, 80, 25 );
  450.  
  451.          Draw_Menu_Frame( 10, 2, 51, 23, Menu_Frame_Color,
  452.                           Menu_Text_Color, 'Revise Dialing Entry ');
  453.  
  454.          Window( 11, 3, 50, 22 );
  455.                                    (* Read in revisions *)
  456.          WITH Fixed_Entry DO
  457.             BEGIN  (* Get revisions *)
  458.  
  459.                GoToXY ( 2 , 2 );
  460.                WRITELN('Old Name: ', Phone_Name );
  461.  
  462.                GoToXY( 2 , 3 );
  463.                WRITE ('New Name: ');
  464.                READLN( Snumber );
  465.  
  466.                IF LENGTH( Snumber ) > 0 THEN
  467.                   CopyStoA( Snumber , Phone_Name , 25 );
  468.  
  469.                GoToXY ( 2 , 5 );
  470.                WRITELN('Old Number: ', Phone_Number );
  471.  
  472.                GoToXY( 2 , 6 );
  473.                WRITE ('New Number: ');
  474.                READLN( Snumber );
  475.  
  476.                IF LENGTH( Snumber ) > 0 THEN
  477.                   CopyS2AR( Snumber , Phone_Number , 15 );
  478.  
  479.                GoToXY( 2 , 8 );
  480.                WRITELN('Old Baud Rate: ', Phone_Baud );
  481.  
  482.                GoToXY( 2 , 9 );
  483.                WRITE ('New Baud Rate: ');
  484.                READLN( Snumber );
  485.  
  486.                IF LENGTH( Snumber ) > 0 THEN
  487.                   CopyS2AR( Snumber , Phone_Baud, 5 );
  488.  
  489.                GoToXY( 2 , 11 );
  490.                WRITELN('Old Parity: ', Phone_Parity );
  491.  
  492.                GoToXY( 2 , 12 );
  493.                WRITE ('New Parity: ');
  494.                READLN( Snumber );
  495.  
  496.                IF LENGTH( Snumber ) > 0 THEN
  497.                   IF UpCase( Snumber[1] ) IN ['E','O','N'] THEN
  498.                      Phone_Parity := UpCase(Snumber[1]);
  499.  
  500.                GoToXY ( 2 , 14 );
  501.                WRITELN('Old Data Bits: ', Phone_DataBits );
  502.  
  503.                GoToXY ( 2 , 15 );
  504.                WRITE  ('New Data Bits: ');
  505.                READLN ( Snumber );
  506.  
  507.                IF LENGTH( Snumber ) > 0 THEN
  508.                   IF Snumber[1] IN ['5'..'8'] THEN
  509.                      Phone_DataBits := Snumber[1];
  510.  
  511.                GoToXY( 2 , 17 );
  512.                WRITELN('Old Stop Bits: ', Phone_StopBits );
  513.  
  514.                GoToXY( 2 , 18 );
  515.                WRITE  ('New Stop Bits: ');
  516.                READLN( Snumber );
  517.  
  518.                IF LENGTH( Snumber ) > 0 THEN
  519.                   IF Snumber[1] IN ['1'..'2'] THEN
  520.                      Phone_StopBits := Snumber[1];
  521.  
  522.                                    (* Write revised entry back to *)
  523.                                    (* phone directory file        *)
  524.  
  525.                SEEK ( Phone_File , J - 1 );
  526.                WRITE( Phone_File , Fixed_Entry );
  527.  
  528.                Restore_Screen( Local_Save_2 );
  529.  
  530.             END (* Get Revisions *);
  531.  
  532.       END (* Entry exists *);
  533.  
  534. END   (* Revise_Phone_Entry *);
  535.  
  536. (*----------------------------------------------------------------------*)
  537. (*            Revise_Dialing_Prefix --- Revise dialing prefix           *)
  538. (*----------------------------------------------------------------------*)
  539.  
  540. PROCEDURE Revise_Dialing_Prefix;
  541.  
  542. (*----------------------------------------------------------------------*)
  543. (*                                                                      *)
  544. (*     Procedure:  Revise_Dialing_Prefix                                *)
  545. (*                                                                      *)
  546. (*     Purpose:    Handles revision of dialing prefix or setting of     *)
  547. (*                 default prefix.                                      *)
  548. (*                                                                      *)
  549. (*     Calling Sequence:                                                *)
  550. (*                                                                      *)
  551. (*        Revise_Dialing_Prefix;                                        *)
  552. (*                                                                      *)
  553. (*     Calls:   Save_Screen                                             *)
  554. (*              Draw_Menu_Frame                                         *)
  555. (*              Save_Screen                                             *)
  556. (*              Restore_Screen                                          *)
  557. (*              Get_New_Dialing_Prefix                                  *)
  558. (*              Get_New_Default_Prefix                                  *)
  559. (*                                                                      *)
  560. (*----------------------------------------------------------------------*)
  561.  
  562. VAR
  563.    Prefix_Menu  : Menu_Type;
  564.  
  565. (*----------------------------------------------------------------------*)
  566.  
  567. PROCEDURE Get_New_Dialing_Prefix;
  568.  
  569. VAR
  570.    I:       INTEGER;
  571.    Done:    BOOLEAN;
  572.    Pchar:   CHAR;
  573.    Changed: BOOLEAN;
  574.  
  575. BEGIN (* Get_New_Dialing_Prefix *)
  576.  
  577.                                    (* Bring up revision window *)
  578.    Save_Screen( Local_Save_2 );
  579.  
  580.    Window( 1, 1, 80, 25 );
  581.  
  582.    Draw_Menu_Frame( 10, 2, 65, 10, Menu_Frame_Color,
  583.                     Menu_Text_Color, 'Revise Dialing Prefix');
  584.  
  585.    Window( 11, 3, 64, 9 );
  586.  
  587.    Done    := FALSE;
  588.    Changed := FALSE;
  589.  
  590.    REPEAT
  591.  
  592.       GoToXY( 1 , 2 );
  593.  
  594.       FOR I := 1 TO Max_Phone_Prefixes DO
  595.          BEGIN
  596.             ClrEol;
  597.             WRITELN( ' ', Phone_Prefix_Chars[I], ' = ', Phone_Prefix_Nos[I] );
  598.          END;
  599.  
  600.       WRITELN(' ');
  601.  
  602.       REPEAT
  603.          GoToXY( 2 , WhereY );
  604.          WRITE('Enter prefix character to revise: ');
  605.          ClrEol;
  606.          READ( Kbd, Pchar );
  607.          IF NOT ( Pchar IN ['+','-','!','@','#',CHR(CR)] ) THEN
  608.             Menu_Beep;
  609.       UNTIL( Pchar IN ['+','-','!','@','#',CHR(CR)] );
  610.  
  611.       IF Pchar <> CHR(CR) THEN
  612.          BEGIN
  613.  
  614.             GoToXY( 2 , WhereY );
  615.             WRITE('Enter new prefix for ',Pchar,':');
  616.             ClrEol;
  617.  
  618.             READLN( Snumber );
  619.  
  620.             Phone_Prefix_Nos[ POS( Pchar , '+-!@#' ) ] := Snumber;
  621.  
  622.             Changed := TRUE;
  623.  
  624.          END
  625.       ELSE
  626.          Done := TRUE;
  627.  
  628.    UNTIL( Done );
  629.                                    (* Rewrite prefix file if changed *)
  630.  
  631.    IF Changed THEN
  632.       BEGIN
  633.  
  634.          ASSIGN( Phone_Prefix_File , Home_Dir + 'PIBTERM.PRE' );
  635.                    (*$I-*)
  636.          REWRITE( Phone_Prefix_File );
  637.                    (*$I+*)
  638.  
  639.          ClrScr;
  640.  
  641.          IF Int24Result <> 0 THEN
  642.             WRITELN(' Can''t create revised PIBTERM.PRE')
  643.          ELSE
  644.             BEGIN
  645.  
  646.                WRITELN(' Writing revised PIBTERM.PRE -- phone prefix file.');
  647.  
  648.                FOR I := 1 TO Max_Phone_Prefixes DO
  649.                   WRITELN( Phone_Prefix_File , Phone_Prefix_Nos[ I ] );
  650.  
  651.                CLOSE( Phone_Prefix_File );
  652.  
  653.             END;
  654.  
  655.          DELAY( Two_Second_Delay );
  656.  
  657.       END;
  658.  
  659.    Restore_Screen( Local_Save_2 );
  660.  
  661. END   (* Get_New_Dialing_Prefix *);
  662.  
  663. (*----------------------------------------------------------------------*)
  664.  
  665. PROCEDURE Get_New_Default_Prefix;
  666.  
  667. VAR
  668.    Done:  BOOLEAN;
  669.    Pchar: CHAR;
  670.  
  671. BEGIN (* Get_New_Default_Prefix *)
  672.                                    (* Bring up revision window *)
  673.    Save_Screen( Local_Save_2 );
  674.  
  675.    Window( 1, 1, 80, 25 );
  676.  
  677.    Draw_Menu_Frame( 10, 10, 65, 15, Menu_Frame_Color,
  678.                     Menu_Text_Color, 'Set Default Dialing Prefix');
  679.  
  680.    Window( 11, 11, 64, 14 );
  681.  
  682.    Done := FALSE;
  683.  
  684.    REPEAT
  685.       GoToXY( 1 , WhereY );
  686.       WRITE('Enter default prefix character: ');
  687.       ClrEol;
  688.       READ( Kbd, Pchar );
  689.       WRITE( Pchar );
  690.       IF NOT ( Pchar IN ['+','-','!','@','#',CHR(CR)] ) THEN
  691.          Menu_Beep;
  692.    UNTIL( Pchar IN ['+','-','!','@','#',CHR(CR)] );
  693.  
  694.    IF Pchar <> CHR(CR) THEN
  695.       Default_Prefix := Pchar
  696.    ELSE
  697.       Default_Prefix := ' ';
  698.  
  699.    DELAY( One_Second_Delay );
  700.  
  701.    Restore_Screen( Local_Save_2 );
  702.  
  703. END   (* Get_New_Default_Prefix *);
  704.  
  705. (*----------------------------------------------------------------------*)
  706.  
  707. BEGIN (* Revise_Dialing_Prefix *)
  708.                                    (* Bring up revision menu *)
  709.    WITH Prefix_Menu DO
  710.       BEGIN
  711.  
  712.          Menu_Size    := 2;
  713.          Menu_Default := 1;
  714.          Menu_Row     := 11;
  715.          Menu_Column  := 30;
  716.          Menu_Tcolor  := Menu_Text_Color;
  717.          Menu_Bcolor  := BackGround_Color;
  718.          Menu_Fcolor  := Menu_Frame_Color;
  719.          Menu_Width   := 0;
  720.          Menu_Height  := 0;
  721.  
  722.       END (* WITH Prefix_Menu *);
  723.  
  724.    FOR I := 1 TO 2 DO
  725.       WITH Prefix_Menu.Menu_Entries[I] DO
  726.       BEGIN
  727.          Menu_Item_Row    := I;
  728.          Menu_Item_Column := 2;
  729.          CASE I OF
  730.             1:  Menu_Item_Text := 'Revise prefix string';
  731.             2:  Menu_Item_Text := 'Set default prefix';
  732.          END (* CASE *);
  733.       END;
  734.  
  735.    Prefix_Menu.Menu_Title := 'Choose prefix revision function:';
  736.  
  737.    Menu_Display_Choices( Prefix_Menu );
  738.  
  739.    CASE Menu_Get_Choice( Prefix_Menu , Erase_Menu ) OF
  740.       1: Get_New_Dialing_Prefix;
  741.       2: Get_New_Default_Prefix;
  742.    END (* Case *);
  743.  
  744. END   (* Revise_Dialing_Prefix *);
  745.  
  746. (*----------------------------------------------------------------------*)
  747. (*            Clear_Dialing_Entry --- Clear dialing entry               *)
  748. (*----------------------------------------------------------------------*)
  749.  
  750. PROCEDURE Clear_Dialing_Entry;
  751.  
  752. (*----------------------------------------------------------------------*)
  753. (*                                                                      *)
  754. (*     Procedure:  Clear_Dialing_Entry                                  *)
  755. (*                                                                      *)
  756. (*     Purpose:    Clear out entry in dialing directory                 *)
  757. (*                                                                      *)
  758. (*     Calling Sequence:                                                *)
  759. (*                                                                      *)
  760. (*        Clear_Dialing_Entry;                                          *)
  761. (*                                                                      *)
  762. (*     Calls:   CopySToA                                                *)
  763. (*              Menu_Beep                                               *)
  764. (*                                                                      *)
  765. (*----------------------------------------------------------------------*)
  766.  
  767. BEGIN (* Clear_Dialing_Entry *)
  768.  
  769.                                    (* Bring up clear entry window *)
  770.    Save_Screen( Local_Save_2 );
  771.  
  772.    Window( 1, 1, 80, 25 );
  773.  
  774.    Draw_Menu_Frame( 10, 2, 65, 5, Menu_Frame_Color,
  775.                     Menu_Text_Color, 'Clear Entry');
  776.  
  777.    Window( 11, 3, 64, 4 );
  778.  
  779.    GoToXY( 1 , 1 );
  780.                                    (* Get entry to clear out *)
  781.  
  782.    WRITE('Enter # of entry to clear: ');
  783.       (*$I-*)
  784.    READLN( Snumber );
  785.       (*$I+*)
  786.  
  787.    VAL( Snumber, I, J );
  788.                                    (* Check if legitimate *)
  789.    IF ( J = 0 ) AND
  790.       ( I > 0 ) AND ( I < Default_Phone_Number_Size ) THEN
  791.       BEGIN
  792.                                    (* If so, clear it     *)
  793.          WITH Phone_Entry_Data DO
  794.             BEGIN
  795.  
  796.                CopyStoA( Dupl( '-' , 25 ) , Phone_Name ,   25 );
  797.                CopyStoA( ' # ### ###-####' , Phone_Number , 15 );
  798.  
  799.                Phone_Parity   := ' ';
  800.                Phone_Baud     := ' ----';
  801.                Phone_DataBits := ' ';
  802.                Phone_StopBits := ' ';
  803.  
  804.             END;
  805.  
  806.          SEEK ( Phone_File , I - 1 );
  807.          WRITE( Phone_File , Phone_Entry_Data );
  808.  
  809.       END
  810.    ELSE
  811.       Menu_Beep;
  812.  
  813.    Restore_Screen( Local_Save_2 );
  814.  
  815. END   (* Clear_Dialing_Entry *);
  816.  
  817. (*----------------------------------------------------------------------*)
  818. (*            Extract_Dialing_Entry --- Get number to dial              *)
  819. (*----------------------------------------------------------------------*)
  820.  
  821. PROCEDURE Extract_Dialing_Entry( I: INTEGER );
  822.  
  823. (*----------------------------------------------------------------------*)
  824. (*                                                                      *)
  825. (*     Procedure:  Extract_Dialing_Entry                                *)
  826. (*                                                                      *)
  827. (*     Purpose:    Read entry from dialing directory file               *)
  828. (*                                                                      *)
  829. (*     Calling Sequence:                                                *)
  830. (*                                                                      *)
  831. (*        Extract_Dialing_Entry( I : INTEGER );                         *)
  832. (*                                                                      *)
  833. (*           I --- If  > 0, then entry to dial;                         *)
  834. (*                 If <= 0, then get entry from input.                  *)
  835. (*                                                                      *)
  836. (*     Calls:   Reset_Comm_Params                                       *)
  837. (*                                                                      *)
  838. (*     Remarks:                                                         *)
  839. (*                                                                      *)
  840. (*        The current communications parameters are reset to match      *)
  841. (*        present in the selected dialing directory entry.              *)
  842. (*                                                                      *)
  843. (*----------------------------------------------------------------------*)
  844.  
  845. VAR
  846.    OK_Number: BOOLEAN;
  847.    Ch       : CHAR;
  848.    IX       : INTEGER;
  849.    IY       : INTEGER;
  850.    Quit     : BOOLEAN;
  851.    Use_DP   : BOOLEAN;
  852.  
  853. BEGIN (* Extract_Dialing_Entry *)
  854.                                    (* Initialize dialing entry *)
  855.    Snumber    := '';
  856.    Prefix_Str := '';
  857.  
  858.    Quit       := FALSE;
  859.    Use_DP     := FALSE;
  860.                                    (* We entered with first character *)
  861.                                    (* in Dial_Func if I <= 0.         *)
  862.  
  863.    IF I <= 0 THEN
  864.       Read_Number_Or_ESC( Dial_Func, Xpos, SNumber, Prefix_Str, Quit, I )
  865.    ELSE
  866.       Use_DP := Default_Prefix <> ' ';
  867.  
  868.  
  869.                                    (* No number entered -- quit *)
  870.    IF ( Quit OR ( I <= 0 ) ) THEN EXIT;
  871.  
  872.                                    (* Extract phone number from directory *)
  873.       (*$I-*)
  874.    SEEK( Phone_File , I - 1 );
  875.       (*$I+*)
  876.  
  877.    IF ( Int24Result <> 0 ) THEN EXIT;
  878.  
  879.    READ( Phone_File , Phone_Entry_Data );
  880.  
  881.    Phone_Number := Phone_Entry_Data.Phone_Number;
  882.  
  883.                                    (* Use default dialing prefix if       *)
  884.                                    (* number is > 7 digits.               *)
  885.    IF Use_DP THEN
  886.       BEGIN
  887.          IX := 0;
  888.          FOR I := 1 TO LENGTH( Phone_Number ) DO
  889.             IF ( Phone_Number[I] IN ['0'..'9'] ) THEN
  890.                IX := IX + 1;
  891.          IF ( IX > 7 ) THEN
  892.             Prefix_Str := Phone_Prefix_Nos[ POS( Default_Prefix, '+-!@#' ) ];
  893.       END;
  894.  
  895.    Done := TRUE;
  896.                                    (* If session not already in progress, *)
  897.                                    (* change comm parms to match dialing  *)
  898.                                    (* directory entry.                    *)
  899.  
  900.    IF ( NOT Dialer_Carrier_Detect ) THEN
  901.       Reset_Comm_Params( Phone_Entry_Data );
  902.  
  903. END   (* Extract_Dialing_Entry *);
  904.  
  905. (*----------------------------------------------------------------------*)
  906. (*     Do_Manual_Dial --- Get number to dial from keyboard entry        *)
  907. (*----------------------------------------------------------------------*)
  908.  
  909. FUNCTION Do_Manual_Dial : BOOLEAN;
  910.  
  911. VAR
  912.    Local_Save_5 : Saved_Screen_Ptr;
  913.    Ch           : CHAR;
  914.    Quit         : BOOLEAN;
  915.    J            : INTEGER;
  916.  
  917. BEGIN (* Do_Manual_Dial *)
  918.  
  919.    Save_Screen( Local_Save_5 );
  920.  
  921.    Window( 1, 1, 80, 25 );
  922.  
  923.    Draw_Menu_Frame( 10, 10, 65, 13, Menu_Frame_Color,
  924.                     Menu_Text_Color, 'Manual Dial');
  925.  
  926.    Window( 11, 11, 64, 12 );
  927.  
  928.    GoToXY( 1 , 1 );
  929.  
  930.    Prefix_Str := '';
  931.    SNumber    := '';
  932.  
  933.    WRITE('Number to dial? ');
  934.    READ( Kbd , Ch );
  935.  
  936.    Read_Number_Or_ESC( Ch , WhereX - 1, SNumber, Prefix_Str, Quit, J );
  937.  
  938.    Restore_Screen( Local_Save_5 );
  939.  
  940.    IF ( NOT Quit ) AND ( LENGTH( Snumber ) > 0 ) THEN
  941.       BEGIN
  942.          Phone_Number   := SNumber;
  943.          Do_Manual_Dial := TRUE;
  944.          Manual_Dial    := TRUE;
  945.       END
  946.    ELSE
  947.       Do_Manual_Dial := FALSE;
  948.  
  949. END   (* Do_Manual_Dial *);
  950.  
  951.  
  952. (*----------------------------------------------------------------------*)
  953. (*     Get_List_Of_Phone_Numbers --- Get up to 5 entries to dial        *)
  954. (*----------------------------------------------------------------------*)
  955.  
  956. PROCEDURE Get_List_Of_Phone_Numbers;
  957.  
  958. VAR
  959.    No_Num  : BOOLEAN;
  960.    N_Nos   : INTEGER;
  961.  
  962. BEGIN (* Get_List_Of_Phone_Numbers *)
  963.  
  964.    N_Nos := 1;
  965.  
  966.    WHILE ( ( N_Nos < Max_Dial_Numbers ) AND ( NOT No_Num ) ) DO
  967.       BEGIN
  968.          N_Nos := N_Nos + 1;
  969.          WRITE('Enter phone number ',N_Nos,': ');
  970.          GoToXY( 25, WhereY );
  971.          Extract_Dialing_Entry( -1 );
  972.          No_Num := ( Snumber = '' );
  973.       END;
  974.  
  975. END   (* Get_List_Of_Phone_Numbers *);
  976.  
  977. (*----------------------------------------------------------------------*)
  978.  
  979.  
  980. BEGIN (* Display_Phone_Numbers *)
  981.  
  982.                                    (* Save dialing box screen *)
  983.    Save_Screen( Local_Save );
  984.                                    (* Get back whole screen as window *)
  985.                                    (* for dialing display             *)
  986.    Window( 1, 1, 80, 25 );
  987.  
  988.    ClrScr;
  989.  
  990.    Draw_Menu_Frame( 1, 1, 79, 25, Menu_Frame_Color,
  991.                     Menu_Text_Color, 'Dialing Directory' );
  992.  
  993.    Window( 2, 2, 78, 24 );
  994.                                    (* Display title                *)
  995.  
  996.    WRITELN('No.  --------- Name ----------',
  997.            '  --- Number ---    -Baud- -Bits- -Par- -Stp- ');
  998.    WRITELN(' ');
  999.  
  1000.    Window( 2, 4, 78, 24 );
  1001.  
  1002.    GoToXY( 1 , N_Nos + 2 );
  1003.    TextColor( Menu_Frame_Color );
  1004.    WRITE  (' -->    R');
  1005.    TextColor( Menu_Text_Color );
  1006.    WRITE  (' Revise entry   ');
  1007.    TextColor( Menu_Frame_Color );
  1008.    WRITE  (' P');
  1009.    TextColor( Menu_Text_Color );
  1010.    WRITE  (' Revise prefix   ');
  1011.    TextColor( Menu_Frame_Color );
  1012.    WRITE  (' C');
  1013.    TextColor( Menu_Text_Color );
  1014.    WRITE  (' Clear entry');
  1015.    TextColor( Menu_Frame_Color );
  1016.    WRITE  ('    Q');
  1017.    TextColor( Menu_Text_Color );
  1018.    WRITELN(' Redial');
  1019.  
  1020.    TextColor( Menu_Frame_Color );
  1021.    WRITE  ('        PgUp/PgDn');
  1022.    TextColor( Menu_Text_Color );
  1023.    WRITE  (' Page');
  1024.    TextColor( Menu_Frame_Color );
  1025.    WRITE  ('    Esc');
  1026.    TextColor( Menu_Text_Color );
  1027.    WRITE  (' Exit        ');
  1028.    TextColor( Menu_Frame_Color );
  1029.    WRITE  ('   /');
  1030.    TextColor( Menu_Text_Color );
  1031.    WRITE  (' Scroll');
  1032.    TextColor( Menu_Frame_Color );
  1033.    WRITE  ('       H');
  1034.    TextColor( Menu_Text_Color );
  1035.    WRITELN(' Hang up');
  1036.  
  1037.    TextColor( Menu_Frame_Color );
  1038.    WRITE  ('        M ');
  1039.    TextColor( Menu_Text_Color );
  1040.    WRITE  ('Manual dial');
  1041.    TextColor( Menu_Frame_Color );
  1042.    WRITE  ('     Home ');
  1043.    TextColor( Menu_Text_Color );
  1044.    WRITE  ('First page ');
  1045.    TextColor( Menu_Frame_Color );
  1046.    WRITE  ('   End');
  1047.    TextColor( Menu_Text_Color );
  1048.    WRITELN(' Last page');
  1049.  
  1050.    WRITE  ('        Entry');
  1051.    WRITE  (' to dial     ');
  1052.    TextColor( Menu_Frame_Color );
  1053.    WRITE  ('ENTER ');
  1054.    TextColor( Menu_Text_Color );
  1055.    WRITELN('dials highlighted entry');
  1056.  
  1057.    Low_Num      := MIN( MAX( Phone_Entry_Page , 1 ) ,
  1058.                              Default_Phone_Number_Size );
  1059.    Hi_Num       := MIN( Low_Num + N_Nos - 1 , Default_Phone_Number_Size );
  1060.    Done         := FALSE;
  1061.  
  1062.    Esc_Hit      := FALSE;
  1063.    ReDraw       := TRUE;
  1064.                                    (* Display dialing directory until    *)
  1065.                                    (* explicit exit requested or a       *)
  1066.                                    (* phone number selected for dialing  *)
  1067.    REPEAT
  1068.  
  1069.       IF ReDraw THEN
  1070.          BEGIN
  1071.             Display_Directory_Page;
  1072.             GoToXY( 5 , N_Nos + 2 );
  1073.             XPos      := WhereX;
  1074.             YPos      := WhereY;
  1075.             Dial_Func := ' ';
  1076.          END;
  1077.  
  1078.       ReDraw    := TRUE;
  1079.                                    (* Read in dialing command *)
  1080.       GoToXY( Xpos, Ypos );
  1081.  
  1082.       FOR I := 1 TO 4 DO
  1083.          WRITE(' ');
  1084.  
  1085.       GoToXY( Xpos, Ypos );
  1086.                                    (* Get function to perform *)
  1087.       READ( KBD , Dial_Func );
  1088.       Dial_Func := UpCase( Dial_Func );
  1089.  
  1090.                                    (* Check for keypad key *)
  1091.  
  1092.       IF ( ORD( Dial_Func ) = ESC ) AND KeyPressed THEN
  1093.          BEGIN
  1094.  
  1095.             READ( KBD , Dial_Func );
  1096.  
  1097.             CASE ORD( Dial_Func ) OF
  1098.  
  1099.                PgUp:    Dial_Func := 'B';
  1100.                PgDn:    Dial_Func := 'F';
  1101.                U_Arrow: Dial_Func := 'U';
  1102.                D_Arrow: Dial_Func := 'D';
  1103.                End_Key: Dial_Func := 'E';
  1104.                Home:    Dial_Func := 'T';
  1105.                ELSE     Dial_Func := 'Z';
  1106.  
  1107.             END (* CASE *)
  1108.  
  1109.          END
  1110.                                    (* flag invalid letters *)
  1111.  
  1112.       ELSE IF( NOT ( Dial_Func IN ['C','R','P',^[,^H,'0'..'9','+','-','!','@',
  1113.                                    '#',' ',^M, 'M',';','H','Q' ] ) ) THEN
  1114.          Dial_Func := 'Z';
  1115.  
  1116.                                    (* Perform requested dialing command *)
  1117.  
  1118.       CASE Dial_Func OF
  1119.  
  1120.                                    (* Clear dialing entry        *)
  1121.          'C':     Clear_Dialing_Entry;
  1122.  
  1123.                                    (* Exit without dialing anything *)
  1124.          ^[ :     BEGIN
  1125.                      Done    := TRUE;
  1126.                      Esc_Hit := TRUE;
  1127.                   END;
  1128.  
  1129.                                    (* Display next page in directory *)
  1130.  
  1131.          'F':     IF Hi_Num < Default_Phone_Number_Size THEN
  1132.                      BEGIN
  1133.                         Low_Num := Hi_Num + 1;
  1134.                         Hi_Num  := MIN( Low_Num + N_Nos - 1 ,
  1135.                                         Default_Phone_Number_Size );
  1136.                      END;
  1137.  
  1138.                                    (* Display previous page in directory *)
  1139.  
  1140.          'B':     IF Low_Num > 1 THEN
  1141.                      BEGIN
  1142.                         Low_Num := MAX( Low_Num - N_Nos , 1 );
  1143.                         Hi_Num  := MIN( Low_Num + N_Nos - 1 ,
  1144.                                         Default_Phone_Number_Size );
  1145.                      END;
  1146.  
  1147.                                    (* Display first page in directory *)
  1148.  
  1149.          'T':     BEGIN
  1150.                      Low_Num := 1;
  1151.                      Hi_Num  := N_Nos;
  1152.                   END;
  1153.  
  1154.                                    (* Display last page in directory *)
  1155.  
  1156.          'E':     BEGIN
  1157.                      Hi_Num  := Default_Phone_Number_Size;
  1158.                      Low_Num := MAX( Hi_Num - N_Nos + 1 , 1 );
  1159.                   END;
  1160.  
  1161.          'U':     BEGIN (* Scroll up one line *)
  1162.  
  1163.                      Redraw := FALSE;
  1164.  
  1165.                      IF Low_Num > 1 THEN
  1166.                         BEGIN
  1167.  
  1168.                            Window( 2, 4, 78, N_Nos + 3 );
  1169.  
  1170.                                    (* Remove highlight from top line *)
  1171.  
  1172.                            GoToXY( 1 , 1 );
  1173.  
  1174.                            WITH Phone_Entries[1] DO
  1175.                               WRITELN( Low_Num:3, '  ',     Phone_Name:25,
  1176.                                                   '  ',     Phone_Number:15,
  1177.                                                   '   ',    Phone_Baud:5,
  1178.                                                   '    ',   Phone_DataBits:1,
  1179.                                                   '      ', Phone_Parity:1,
  1180.                                                   '     ',  Phone_StopBits:1 );
  1181.  
  1182.                                    (* Make room for new line *)
  1183.  
  1184.                            GoToXY( 1 , 1 );
  1185.                            InsLine;
  1186.  
  1187.                            Low_Num  := Low_Num  - 1;
  1188.                            Hi_Num   := Hi_Num   - 1;
  1189.  
  1190.                                    (* Move current entries up *)
  1191.  
  1192.                            MOVE( Phone_Entries[1], Phone_Entries[2],
  1193.                                  ( N_Nos - 1 ) * SizeOf( Phone_Entries[1] ) );
  1194.  
  1195.                                    (* Get data for new line *)
  1196.  
  1197.                               (*$I-*)
  1198.                            SEEK( Phone_File , Low_Num - 1 );
  1199.                               (*$I+*)
  1200.                            IF Int24Result = 0 THEN
  1201.                               READ( Phone_File , Phone_Entries[ 1 ] );
  1202.  
  1203.                                    (* Draw new line *)
  1204.  
  1205.                            RvsVideoOn( ForeGround_Color , BackGround_Color );
  1206.  
  1207.                            WITH Phone_Entries[1] DO
  1208.                               WRITELN( Low_Num:3, '  ',     Phone_Name:25,
  1209.                                                   '  ',     Phone_Number:15,
  1210.                                                   '   ',    Phone_Baud:5,
  1211.                                                   '    ',   Phone_DataBits:1,
  1212.                                                   '      ', Phone_Parity:1,
  1213.                                                   '     ',  Phone_StopBits:1 );
  1214.                            Window( 2, 4, 78, 24 );
  1215.  
  1216.                            RvsVideoOff( ForeGround_Color , BackGround_Color );
  1217.  
  1218.                         END;
  1219.  
  1220.                   END   (* Scroll up one line *);
  1221.  
  1222.          'D':     BEGIN (* Scroll down one line *)
  1223.  
  1224.                      Redraw := FALSE;
  1225.  
  1226.                      IF Hi_Num < Default_Phone_Number_Size THEN
  1227.                         BEGIN
  1228.                                    (* Make room for new line *)
  1229.  
  1230.                            Window( 2, 4, 78, N_Nos + 4 );
  1231.  
  1232.                            GoToXY( 1 , 1 );
  1233.                            DelLine;
  1234.  
  1235.                            Low_Num  := Low_Num + 1;
  1236.                            Hi_Num   := Hi_Num  + 1;
  1237.  
  1238.                                    (* Move current entries down *)
  1239.  
  1240.                            MOVE( Phone_Entries[2], Phone_Entries[1],
  1241.                                  ( N_Nos - 1 ) * SizeOf( Phone_Entries[1] ) );
  1242.  
  1243.                               (*$I-*)
  1244.                            SEEK( Phone_File , Hi_Num - 1 );
  1245.                               (*$I+*)
  1246.                            IF Int24Result = 0 THEN
  1247.                               READ( Phone_File , Phone_Entries[ N_Nos ] );
  1248.  
  1249.                            GoToXY( 1 , Hi_Num - Low_Num + 1 );
  1250.  
  1251.                            WITH Phone_Entries[ N_Nos ] DO
  1252.                               WRITELN( Hi_Num:3, '  ',     Phone_Name:25,
  1253.                                                  '  ',     Phone_Number:15,
  1254.                                                  '   ',    Phone_Baud:5,
  1255.                                                  '    ',   Phone_DataBits:1,
  1256.                                                  '      ', Phone_Parity:1,
  1257.                                                  '     ',  Phone_StopBits:1 );
  1258.  
  1259.                            RvsVideoOn( ForeGround_Color , BackGround_Color );
  1260.  
  1261.                            GoToXY( 1 , 1 );
  1262.  
  1263.                            WITH Phone_Entries[ 1 ] DO
  1264.                               WRITELN( Low_Num:3, '  ',     Phone_Name:25,
  1265.                                                   '  ',     Phone_Number:15,
  1266.                                                   '   ',    Phone_Baud:5,
  1267.                                                   '    ',   Phone_DataBits:1,
  1268.                                                   '      ', Phone_Parity:1,
  1269.                                                   '     ',  Phone_StopBits:1 );
  1270.  
  1271.                            RvsVideoOff( ForeGround_Color , BackGround_Color );
  1272.  
  1273.                            Window( 2, 4, 78, 23 );
  1274.  
  1275.                         END;
  1276.  
  1277.                   END   (* Scroll down one line *);
  1278.  
  1279.                                    (* Entry to dial *)
  1280.  
  1281.          '0'..'9', '+','-','!','@','#':
  1282.  
  1283.                   IF ( NOT Dialer_Carrier_Detect ) THEN
  1284.                      Extract_Dialing_Entry( -1 )
  1285.                   ELSE
  1286.                      BEGIN
  1287.                         Save_Screen( Local_Save_3 );
  1288.                         Window( 1, 1, 80, 25 );
  1289.                         Draw_Menu_Frame( 10, 10, 60, 14, Menu_Frame_Color,
  1290.                                          Menu_Text_Color + Blink, '' );
  1291.                         WRITELN('Session already in progress.');
  1292.                         WRITE  ('Dialing request ignored.');
  1293.                         DELAY( Two_Second_Delay );
  1294.                         Restore_Screen( Local_Save_3 );
  1295.                         TextColor( Menu_Text_Color );
  1296.                         ReDraw    := FALSE;
  1297.                      END;
  1298.                                    (* Revise/add a dialing entry *)
  1299.  
  1300.          'R':     Revise_Phone_Entry;
  1301.  
  1302.                                    (* Revise dialing prefix      *)
  1303.  
  1304.          'P':     BEGIN
  1305.                      Revise_Dialing_Prefix;
  1306.                      Redraw := FALSE;
  1307.                   END;
  1308.                                    (* Start a redial             *)
  1309.  
  1310.          'Q':     BEGIN
  1311.                      IF Phone_Number = '' THEN
  1312.                         Extract_Dialing_Entry( Low_Num );
  1313.                      Done   := TRUE;
  1314.                      ReDial := TRUE;
  1315.                   END;
  1316.  
  1317.                                    (* Ignore extraneous backspace *)
  1318.          ^H:      BEGIN
  1319.                      Redraw := FALSE;
  1320.                   END;
  1321.  
  1322.                                    (* Hang up the phone *)
  1323.          'H':     BEGIN
  1324.  
  1325.                      Redraw := FALSE;
  1326.  
  1327.                      Save_Screen( Local_Save_2 );
  1328.  
  1329.                      Draw_Menu_Frame( 10, 10, 60, 15, Menu_Frame_Color,
  1330.                                       Menu_Text_Color, '' );
  1331.  
  1332.                      WRITELN;
  1333.                      WRITELN('*** Hanging up the phone ***');
  1334.  
  1335.                                    (* Hang up the phone *)
  1336.  
  1337.                      HangUpPhone;
  1338.  
  1339.                      IF Async_Carrier_Detect THEN
  1340.                         WRITELN('*** Phone not hung up, try again ***')
  1341.                      ELSE
  1342.                         BEGIN
  1343.                            WRITELN('*** Phone hung up ***');
  1344.                            Qerr := Async_Open( Comm_Port, Baud_Rate,
  1345.                                                Parity, Data_Bits,
  1346.                                                Stop_Bits );
  1347.                         END;
  1348.  
  1349.                      DELAY( Two_Second_Delay );
  1350.  
  1351.                      Restore_Screen( Local_Save_2 );
  1352.                      TextColor( Menu_Text_Color );
  1353.  
  1354.                   END;
  1355.  
  1356.                                    (* Dial top number on screen *)
  1357.          ^M,
  1358.          ' ':     IF ( NOT Dialer_Carrier_Detect ) THEN
  1359.                      Extract_Dialing_Entry( Low_Num )
  1360.                   ELSE
  1361.                      BEGIN
  1362.                         Save_Screen( Local_Save_3 );
  1363.                         Window( 1, 1, 80, 25 );
  1364.                         Draw_Menu_Frame( 10, 10, 60, 14, Menu_Frame_Color,
  1365.                                          Menu_Text_Color + Blink, '' );
  1366.                         WRITELN('Session already in progress.');
  1367.                         WRITE  ('Dialing request ignored.');
  1368.                         DELAY( Two_Second_Delay );
  1369.                         Restore_Screen( Local_Save_3 );
  1370.                         TextColor( Menu_Text_Color );
  1371.                         ReDraw    := FALSE;
  1372.                      END;
  1373.  
  1374.                                    (* Manual dial *)
  1375.          'M':     BEGIN
  1376.                      Done   := Do_Manual_Dial;
  1377.                      ReDraw := FALSE;
  1378.                   END;
  1379.  
  1380.                                    (* ';' -- list of numbers given *)
  1381.          ';':     BEGIN
  1382.                      Save_Screen( Local_Save_3 );
  1383.                      Window( 1, 1, 80, 25 );
  1384.                      Draw_Menu_Frame( 10, 10, 60, 18, Menu_Frame_Color,
  1385.                                       Menu_Text_Color, 'Numbers to Dial' );
  1386.                      Get_List_Of_Phone_Numbers;
  1387.                      Restore_Screen( Local_Save_3 );
  1388.                      TextColor( Menu_Text_Color );
  1389.                      ReDraw    := FALSE;
  1390.                   END;
  1391.                                    (* Beep on anything else -- bad *)
  1392.          ELSE
  1393.             Menu_Beep;
  1394.             ReDraw := FALSE;
  1395.  
  1396.       END (* CASE *);
  1397.  
  1398.    UNTIL Done;
  1399.                                    (* Remember current dialing page *)
  1400.  
  1401.    Phone_Entry_Page := Low_Num;
  1402.  
  1403.                                    (* Restore dialing box *)
  1404.    Restore_Screen( Local_Save );
  1405.    Reset_Global_Colors;
  1406.  
  1407. END   (* Display_Phone_Numbers *);
  1408.